
// source idl: com.erp.gis.idl.GisMapGatewayAo.java

#ifndef GISMAPGATEWAYAO_STUB_4_APP_H
#define GISMAPGATEWAYAO_STUB_4_APP_H

#include <string>
#include <sstream>
#include "app_platform/cmd_obj.h"
#include "c2cent/base/basestub4app.h"
#include "app_platform/cntl_info.h"
#include "app_platform/intf_serializable.h"
#include "app_platform/intf_service_object.h"
#include "erp/gis/po/coordinatespo_gis.h"	
#include <map>	
#include <vector>	
#include "erp/gis/po/coordinatesquerypo_gis.h"	
#include "intf_gismapgatewayao.h"

namespace erp
{
namespace gis
{
namespace ao
{
	#define GISMAPGATEWAYAO_STUB4APP_VERSION "ERP_GIS_AO___GISMAPGATEWAYAO__STUB4APP_VERSION__1.0 9d32cf642cc3fa637edcada56a92a83"
    const std::string GISMAPGATEWAYAO_STUB4APP_NOUSE = GISMAPGATEWAYAO_STUB4APP_VERSION;

	const uint32_t GISMAPGATEWAYAO_GETALIYUNCOORDINATES_REQ_CMD_ID = 0xc0541001; /// 请求命令号
	const uint32_t GISMAPGATEWAYAO_GETALIYUNCOORDINATES_RESP_CMD_ID = 0xc0548001; /// 回应命令号
	

	const uint32_t GISMAPGATEWAYAO_GETBAIDUCOORDINATES_REQ_CMD_ID = 0xc0521001; /// 请求命令号
	const uint32_t GISMAPGATEWAYAO_GETBAIDUCOORDINATES_RESP_CMD_ID = 0xc0528001; /// 回应命令号
	

	const uint32_t GISMAPGATEWAYAO_GETGAODECOORDINATES_REQ_CMD_ID = 0xc0551001; /// 请求命令号
	const uint32_t GISMAPGATEWAYAO_GETGAODECOORDINATES_RESP_CMD_ID = 0xc0558001; /// 回应命令号
	

	const uint32_t GISMAPGATEWAYAO_GETGOOGLECOORDINATES_REQ_CMD_ID = 0xc0531001; /// 请求命令号
	const uint32_t GISMAPGATEWAYAO_GETGOOGLECOORDINATES_RESP_CMD_ID = 0xc0538001; /// 回应命令号
	

	const uint32_t GISMAPGATEWAYAO_GETSOSO2COORDINATES_REQ_CMD_ID = 0xc0511001; /// 请求命令号
	const uint32_t GISMAPGATEWAYAO_GETSOSO2COORDINATES_RESP_CMD_ID = 0xc0518001; /// 回应命令号
	

	const uint32_t GISMAPGATEWAYAO_GETSOSOCOORDINATES_REQ_CMD_ID = 0xc0251001; /// 请求命令号
	const uint32_t GISMAPGATEWAYAO_GETSOSOCOORDINATES_RESP_CMD_ID = 0xc0258001; /// 回应命令号
	


	const uint16_t GISMAPGATEWAYAO_MAX_PROTOCAL_VERSION = 2; //>平台支持的最大协议版本号

///////////////////////////// STRUCTS /////////////////////////////////////////////////
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetAliyunCoordinatesReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::gis::po::CCoordinatesQueryPo coordinatesQueryPo;
		std::string inReserve;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETALIYUNCOORDINATES_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > GISMAPGATEWAYAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			coordinatesQueryPo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetAliyunCoordinatesResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETALIYUNCOORDINATES_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & coordinatesPo;
			bs & errMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetBaiduCoordinatesReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::gis::po::CCoordinatesQueryPo coordinatesQueryPo;
		std::string inReserve;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETBAIDUCOORDINATES_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > GISMAPGATEWAYAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			coordinatesQueryPo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetBaiduCoordinatesResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETBAIDUCOORDINATES_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & coordinatesPo;
			bs & errMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetGaodeCoordinatesReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::gis::po::CCoordinatesQueryPo coordinatesQueryPo;
		std::string inReserve;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETGAODECOORDINATES_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > GISMAPGATEWAYAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			coordinatesQueryPo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetGaodeCoordinatesResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETGAODECOORDINATES_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & coordinatesPo;
			bs & errMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetGoogleCoordinatesReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::gis::po::CCoordinatesQueryPo coordinatesQueryPo;
		std::string inReserve;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETGOOGLECOORDINATES_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > GISMAPGATEWAYAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			coordinatesQueryPo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetGoogleCoordinatesResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETGOOGLECOORDINATES_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & coordinatesPo;
			bs & errMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetSoso2CoordinatesReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::gis::po::CCoordinatesQueryPo coordinatesQueryPo;
		std::string inReserve;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETSOSO2COORDINATES_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > GISMAPGATEWAYAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			coordinatesQueryPo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetSoso2CoordinatesResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETSOSO2COORDINATES_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & coordinatesPo;
			bs & errMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetSosoCoordinatesReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::gis::po::CCoordinatesQueryPo coordinatesQueryPo;
		std::string inReserve;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETSOSOCOORDINATES_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > GISMAPGATEWAYAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			coordinatesQueryPo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-21 16:20:34
 	 * @version 0
	 */	
	struct CGetSosoCoordinatesResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::vector<erp::gis::po::CCoordinatesPo > coordinatesPo;
		std::string errMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return GISMAPGATEWAYAO_GETSOSOCOORDINATES_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & coordinatesPo;
			bs & errMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	class CGisMapGatewayAoStub4App : public c2cent::CBaseStub4App, public IGisMapGatewayAo,public IGisMapGatewayAoAsyc{
		public:
			uint32_t GetAliyunCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
			);
			
			uint32_t SendGetAliyunCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
		    );
		    uint32_t RecvGetAliyunCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetAliyunCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetAliyunCoordinatesRespCmd(
		    );
			uint32_t GetBaiduCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
			);
			
			uint32_t SendGetBaiduCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
		    );
		    uint32_t RecvGetBaiduCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetBaiduCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetBaiduCoordinatesRespCmd(
		    );
			uint32_t GetGaodeCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
			);
			
			uint32_t SendGetGaodeCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
		    );
		    uint32_t RecvGetGaodeCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetGaodeCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetGaodeCoordinatesRespCmd(
		    );
			uint32_t GetGoogleCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
			);
			
			uint32_t SendGetGoogleCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
		    );
		    uint32_t RecvGetGoogleCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetGoogleCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetGoogleCoordinatesRespCmd(
		    );
			uint32_t GetSoso2Coordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
			);
			
			uint32_t SendGetSoso2Coordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
		    );
		    uint32_t RecvGetSoso2Coordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetSoso2Coordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetSoso2CoordinatesRespCmd(
		    );
			uint32_t GetSosoCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
			);
			
			uint32_t SendGetSosoCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
		    );
		    uint32_t RecvGetSosoCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetSosoCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetSosoCoordinatesRespCmd(
		    );
	};
	
	/**
	 *
 	 * 获取阿里云地图经纬度 
	 *
		 *@param String machineKey: 机器码，必填，对应网站cookie中的visitkey，若无则填随机值 				
		 *@param String source: 调用来源文件名称，必填 				
		 *@param uint32_t sceneId: 场景id，必填（目前填0即可） 				
		 *@param CoordinatesQueryPo coordinatesQueryPo: 经纬度查询PO 				
		 *@param String inReserve: 请求保留字段 				
		 *@param Vector coordinatesPo: 经纬度PO列表 		
		 *@param String errMsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CGisMapGatewayAoStub4App::GetAliyunCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CGetAliyunCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
			oReq.coordinatesPo = coordinatesPo;
			oReq.errMsg = errMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETALIYUNCOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETALIYUNCOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetAliyunCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CGisMapGatewayAoStub4App::SendGetAliyunCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
	)
	{
	    CGetAliyunCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetAliyunCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETALIYUNCOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETALIYUNCOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetAliyunCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetAliyunCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetAliyunCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::GetGetAliyunCoordinatesRespCmd(
	)
	{	    
	    return GISMAPGATEWAYAO_GETALIYUNCOORDINATES_RESP_CMD_ID;
	}	
	/**
	 *
 	 * 获取baidu地图经纬度 
	 *
		 *@param String machineKey: 机器码，必填，对应网站cookie中的visitkey，若无则填随机值 				
		 *@param String source: 调用来源文件名称，必填 				
		 *@param uint32_t sceneId: 场景id，必填（目前填0即可） 				
		 *@param CoordinatesQueryPo coordinatesQueryPo: 经纬度查询PO 				
		 *@param String inReserve: 请求保留字段 				
		 *@param Vector coordinatesPo: 经纬度PO列表 		
		 *@param String errMsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CGisMapGatewayAoStub4App::GetBaiduCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CGetBaiduCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
			oReq.coordinatesPo = coordinatesPo;
			oReq.errMsg = errMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETBAIDUCOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETBAIDUCOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBaiduCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CGisMapGatewayAoStub4App::SendGetBaiduCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
	)
	{
	    CGetBaiduCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetBaiduCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETBAIDUCOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETBAIDUCOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBaiduCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetBaiduCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBaiduCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::GetGetBaiduCoordinatesRespCmd(
	)
	{	    
	    return GISMAPGATEWAYAO_GETBAIDUCOORDINATES_RESP_CMD_ID;
	}	
	/**
	 *
 	 * 获取高德地图经纬度 
	 *
		 *@param String machineKey: 机器码，必填，对应网站cookie中的visitkey，若无则填随机值 				
		 *@param String source: 调用来源文件名称，必填 				
		 *@param uint32_t sceneId: 场景id，必填（目前填0即可） 				
		 *@param CoordinatesQueryPo coordinatesQueryPo: 经纬度查询PO 				
		 *@param String inReserve: 请求保留字段 				
		 *@param Vector coordinatesPo: 经纬度PO列表 		
		 *@param String errMsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CGisMapGatewayAoStub4App::GetGaodeCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CGetGaodeCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
			oReq.coordinatesPo = coordinatesPo;
			oReq.errMsg = errMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETGAODECOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETGAODECOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetGaodeCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CGisMapGatewayAoStub4App::SendGetGaodeCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
	)
	{
	    CGetGaodeCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetGaodeCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETGAODECOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETGAODECOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetGaodeCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetGaodeCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetGaodeCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::GetGetGaodeCoordinatesRespCmd(
	)
	{	    
	    return GISMAPGATEWAYAO_GETGAODECOORDINATES_RESP_CMD_ID;
	}	
	/**
	 *
 	 * 获取google地图经纬度 
	 *
		 *@param String machineKey: 机器码，必填，对应网站cookie中的visitkey，若无则填随机值 				
		 *@param String source: 调用来源文件名称，必填 				
		 *@param uint32_t sceneId: 场景id，必填（目前填0即可） 				
		 *@param CoordinatesQueryPo coordinatesQueryPo: 经纬度查询PO 				
		 *@param String inReserve: 请求保留字段 				
		 *@param Vector coordinatesPo: 经纬度PO列表 		
		 *@param String errMsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CGisMapGatewayAoStub4App::GetGoogleCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CGetGoogleCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
			oReq.coordinatesPo = coordinatesPo;
			oReq.errMsg = errMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETGOOGLECOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETGOOGLECOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetGoogleCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CGisMapGatewayAoStub4App::SendGetGoogleCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
	)
	{
	    CGetGoogleCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetGoogleCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETGOOGLECOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETGOOGLECOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetGoogleCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetGoogleCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetGoogleCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::GetGetGoogleCoordinatesRespCmd(
	)
	{	    
	    return GISMAPGATEWAYAO_GETGOOGLECOORDINATES_RESP_CMD_ID;
	}	
	/**
	 *
 	 * 获取soso2地图经纬度 
	 *
		 *@param String machineKey: 机器码，必填，对应网站cookie中的visitkey，若无则填随机值 				
		 *@param String source: 调用来源文件名称，必填 				
		 *@param uint32_t sceneId: 场景id，必填（目前填0即可） 				
		 *@param CoordinatesQueryPo coordinatesQueryPo: 经纬度查询PO 				
		 *@param String inReserve: 请求保留字段 				
		 *@param Vector coordinatesPo: 经纬度PO列表 		
		 *@param String errMsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CGisMapGatewayAoStub4App::GetSoso2Coordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CGetSoso2CoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
			oReq.coordinatesPo = coordinatesPo;
			oReq.errMsg = errMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETSOSO2COORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETSOSO2COORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetSoso2CoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CGisMapGatewayAoStub4App::SendGetSoso2Coordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
	)
	{
	    CGetSoso2CoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetSoso2Coordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETSOSO2COORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETSOSO2COORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetSoso2CoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetSoso2Coordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetSoso2CoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::GetGetSoso2CoordinatesRespCmd(
	)
	{	    
	    return GISMAPGATEWAYAO_GETSOSO2COORDINATES_RESP_CMD_ID;
	}	
	/**
	 *
 	 * 获取soso地图经纬度 
	 *
		 *@param String machineKey: 机器码，必填，对应网站cookie中的visitkey，若无则填随机值 				
		 *@param String source: 调用来源文件名称，必填 				
		 *@param uint32_t sceneId: 场景id，必填（目前填0即可） 				
		 *@param CoordinatesQueryPo coordinatesQueryPo: 经纬度查询PO 				
		 *@param String inReserve: 请求保留字段 				
		 *@param Vector coordinatesPo: 经纬度PO列表 		
		 *@param String errMsg: 错误信息 		
		 *@param String outReserve: 请求保留字段 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CGisMapGatewayAoStub4App::GetSosoCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CGetSosoCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
			oReq.coordinatesPo = coordinatesPo;
			oReq.errMsg = errMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETSOSOCOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETSOSOCOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetSosoCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CGisMapGatewayAoStub4App::SendGetSosoCoordinates(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::gis::po::CCoordinatesQueryPo& coordinatesQueryPo,
				const std::string& inReserve
	)
	{
	    CGetSosoCoordinatesReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.coordinatesQueryPo = coordinatesQueryPo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetSosoCoordinates(
				const CCntlInfo& rCntlInfo,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(GISMAPGATEWAYAO_GETSOSOCOORDINATES_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << GISMAPGATEWAYAO_GETSOSOCOORDINATES_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetSosoCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::RecvGetSosoCoordinates(
		  		CCmdObj& rCmd,
				std::vector<erp::gis::po::CCoordinatesPo >& coordinatesPo,
				std::string& errMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetSosoCoordinatesResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			coordinatesPo  = oResp.coordinatesPo;
			errMsg  = oResp.errMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CGisMapGatewayAoStub4App::GetGetSosoCoordinatesRespCmd(
	)
	{	    
	    return GISMAPGATEWAYAO_GETSOSOCOORDINATES_RESP_CMD_ID;
	}	
		
}
}
}

#endif /* GISMAPGATEWAYAO_STUB_4_APP_H */
